home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xconq / order.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  6KB  |  275 lines
  1. /* Copyright (c) 1987, 1988  Stanley T. Shebs, University of Utah. */
  2. /* This program may be used, copied, modified, and redistributed freely */
  3. /* for noncommercial purposes, so long as this notice remains intact. */
  4.  
  5. #pragma comment(exestr, "@(#) order.c 12.1 95/05/09 ")
  6.  
  7. /* RCS $Header: order.c,v 1.1 88/06/21 12:30:30 shebs Exp $ */
  8.  
  9. #include "config.h"
  10. #include "misc.h"
  11. #include "dir.h"
  12. #include "period.h"
  13. #include "side.h"
  14. #include "unit.h"
  15.  
  16. char *ordernames[] = ORDERNAMES;   /* full names of orders */
  17. char *dirnames[] = DIRNAMES;       /* short names of directions */
  18. char orderbuf[BUFSIZE];            /* buffer for printed form of an order */
  19. char oargbuf[BUFSIZE];             /* buffer for order's arguments */
  20.  
  21. int orderargs[] = ORDERARGS;       /* types of parameters for each order */
  22.  
  23. /* General routine to wake a unit up (and maybe all its cargo). */
  24.  
  25. wake_unit(unit, wakeocc)
  26. Unit *unit;
  27. bool wakeocc;
  28. {
  29.     Unit *occ;
  30.  
  31.     unit->orders.type = AWAKE;
  32.     unit->orders.rept = 0;
  33.     unit->orders.flags = NORMAL;
  34.     if (wakeocc) {
  35.     for_all_occupants(unit, occ) wake_unit(occ, wakeocc);
  36.     }
  37. }
  38.  
  39. /* Stash a "wakeup call" - will only be for main unit, not occupants. */
  40.  
  41. cache_awake(side)
  42. Side *side;
  43. {
  44.     side->tmporder->type = AWAKE;
  45.     side->tmporder->rept = 0;
  46.     finish_teach(side);
  47. }
  48.  
  49. /* Give a unit sentry orders. */
  50.  
  51. order_sentry(unit, n)
  52. Unit *unit;
  53. int n;
  54. {
  55.     unit->orders.type = SENTRY;
  56.     unit->orders.rept = n;
  57. }
  58.  
  59. /* Stash sentry orders. */
  60.  
  61. cache_sentry(side, n)
  62. Side *side;
  63. int n;
  64. {
  65.     side->tmporder->type = SENTRY;
  66.     side->tmporder->rept = n;
  67.     finish_teach(side);
  68. }
  69.  
  70. /* Fill in the given unit with direction-moving orders. */
  71.  
  72. order_movedir(unit, dir, n)
  73. Unit *unit;
  74. int dir, n;
  75. {
  76.     unit->orders.type = MOVEDIR;
  77.     unit->orders.p.dir = dir;
  78.     unit->orders.rept = n;
  79. }
  80.  
  81. cache_movedir(side, dir, n)
  82. Side *side;
  83. int dir, n;
  84. {
  85.     side->tmporder->type = MOVEDIR;
  86.     side->tmporder->p.dir = dir;
  87.     side->tmporder->rept = n;
  88.     finish_teach(side);
  89. }
  90.  
  91. /* Give the unit orders to move to a given place - it only needs to do this */
  92. /* once, repetition is nonsensical. */
  93.  
  94. order_moveto(unit, x, y)
  95. Unit *unit;
  96. int x, y;
  97. {
  98.     unit->orders.type = MOVETO;
  99.     unit->orders.rept = 1;
  100.     unit->orders.p.pt[0].x = x;
  101.     unit->orders.p.pt[0].y = y;
  102. }
  103.  
  104. cache_moveto(side, x, y)
  105. Side *side;
  106. int x, y;
  107. {
  108.     side->tmporder->type = MOVETO;
  109.     side->tmporder->rept = 1;
  110.     side->tmporder->p.pt[0].x = x;
  111.     side->tmporder->p.pt[0].y = y;
  112.     finish_teach(side);
  113. }
  114.  
  115. /* Order to follow an edge just needs to remember the direction. */
  116.  
  117. order_edge(unit, d, n)
  118. Unit *unit;
  119. int d, n;
  120. {
  121.     unit->orders.type = EDGE;
  122.     unit->orders.rept = n;
  123.     unit->orders.p.dir = d;
  124. }
  125.  
  126. cache_edge(side, d, n)
  127. Side *side;
  128. int d, n;
  129. {
  130.     side->tmporder->type = EDGE;
  131.     side->tmporder->rept = n;
  132.     side->tmporder->p.dir = d;
  133.     finish_teach(side);
  134. }
  135.  
  136. /* Order to follow a unit just needs the unit to follow. */
  137.  
  138. order_follow(unit, leader, n)
  139. Unit *unit, *leader;
  140. int n;
  141. {
  142.     unit->orders.type = FOLLOW;
  143.     unit->orders.rept = n;
  144.     unit->orders.p.leader = leader;
  145. }
  146.  
  147. cache_follow(side, leader, n)
  148. Side *side;
  149. Unit *leader;
  150. int n;
  151. {
  152.     side->tmporder->type = FOLLOW;
  153.     side->tmporder->rept = n;
  154.     side->tmporder->p.leader = leader;
  155.     finish_teach(side);
  156. }
  157.  
  158. /* A two-waypoint patrol suffices for many purposes. */
  159. /* Should have a more general patrol routine eventually (> 2 waypoints). */
  160.  
  161. order_patrol(unit, x0, y0, x1, y1, n)
  162. Unit *unit;
  163. int x0, y0, x1, y1, n;
  164. {
  165.     unit->orders.type = PATROL;
  166.     unit->orders.rept = n;
  167.     unit->orders.p.pt[0].x = x0;
  168.     unit->orders.p.pt[0].y = y0;
  169.     unit->orders.p.pt[1].x = x1;
  170.     unit->orders.p.pt[1].y = y1;
  171. }
  172.  
  173. cache_patrol(side, x0, y0, x1, y1, n)
  174. Side *side;
  175. int x0, y0, x1, y1, n;
  176. {
  177.     side->tmporder->type = PATROL;
  178.     side->tmporder->rept = n;
  179.     side->tmporder->p.pt[0].x = x0;
  180.     side->tmporder->p.pt[0].y = y0;
  181.     side->tmporder->p.pt[1].x = x1;
  182.     side->tmporder->p.pt[1].y = y1;
  183.     finish_teach(side);
  184. }
  185.  
  186. /* Switch from standing order teaching mode back to normal, and confirm */
  187. /* that the standing order has been set. */
  188.  
  189. finish_teach(side)
  190. Side *side;
  191. {
  192.     Unit *occ;
  193.  
  194.     side->teach = FALSE;
  195.     side->sounit->standing->orders[side->soutype] = side->tmporder;
  196.     notify(side, "%s has orders for %s to %s.",
  197.        unit_handle(side, side->sounit), utypes[side->soutype].name,
  198.        order_desig(side->tmporder));
  199.     for_all_occupants(side->sounit, occ) {
  200.     if (occ->type == side->soutype) {
  201.         copy_orders(&(occ->orders), side->tmporder);
  202.     }
  203.     }
  204.     show_timemode(side);
  205. }
  206.  
  207. /* Display orders in some coherent fashion.  Use the information about the */
  208. /* types of order parameters to decide how to display them. */
  209.  
  210. char *
  211. order_desig(orders)
  212. Order *orders;
  213. {
  214.     switch (orderargs[orders->type]) {
  215.     case NOARG:
  216.     sprintf(oargbuf, "");
  217.     break;
  218.     case DIR:
  219.     sprintf(oargbuf, "%s ", dirnames[orders->p.dir]);
  220.     break;
  221.     case POS:
  222.     sprintf(oargbuf, "%d,%d ", orders->p.pt[0].x, orders->p.pt[0].y);
  223.     break;
  224.     case LEADER:
  225.     sprintf(oargbuf, "%s ", unit_handle(NULL, orders->p.leader));
  226.     break;
  227.     case WAYPOINTS:
  228.     sprintf(oargbuf, "%d,%d %d,%d ",
  229.         orders->p.pt[0].x, orders->p.pt[0].y,
  230.         orders->p.pt[1].x, orders->p.pt[1].y);
  231.     break;
  232.     default:
  233.     case_panic("order arg type", orderargs[orders->type]);
  234.     }
  235.     if (orders->rept > 1)
  236.     sprintf(orderbuf, "%s %s(%d)",
  237.         ordernames[orders->type], oargbuf, orders->rept);
  238.     else
  239.     sprintf(orderbuf, "%s %s",
  240.         ordernames[orders->type], oargbuf);
  241.     return orderbuf;
  242. }
  243.  
  244. /* Yeah yeah, assignment statements supposedly copy structures. */
  245.  
  246. copy_orders(dst, src)
  247. Order *dst, *src;
  248. {
  249.     dst->type = src->type;
  250.     dst->rept = src->rept;
  251.     dst->flags = src->flags;
  252.     switch (orderargs[src->type]) {
  253.     case NOARG:
  254.     break;
  255.     case DIR:
  256.     dst->p.dir = src->p.dir;
  257.     break;
  258.     case POS:
  259.     dst->p.pt[0].x = src->p.pt[0].x;
  260.     dst->p.pt[0].y = src->p.pt[0].y;
  261.     break;
  262.     case LEADER:
  263.     /* ??? */
  264.     break;
  265.     case WAYPOINTS:    
  266.     dst->p.pt[0].x = src->p.pt[0].x;
  267.     dst->p.pt[0].y = src->p.pt[0].y;
  268.     dst->p.pt[1].x = src->p.pt[1].x;
  269.     dst->p.pt[1].y = src->p.pt[1].y;
  270.     break;
  271.     default:
  272.     case_panic("order arg type", orderargs[src->type]);
  273.     }
  274. }
  275.